// src/hooks/useModuleState.js
import { computed, ref, watch } from 'vue';
import router from '@/router';

// 类型定义
interface HashState {
  moduleId: number | null;
  apiId: number | null;
}

interface Module {
  id: number;
  name: string;
  children?: Module[];
  apis?: any[];
}

// 创建一个全局的hash状态管理
export const globalHashState = ref<HashState>({ moduleId: null, apiId: null });

// 存储所有模块的状态更新函数
export const moduleStateUpdaters = new Set<() => void>();

// 存储所有模块的展开状态管理函数
export const moduleExpandManagers = new Map<
  number,
  { setExpanded: (expanded: boolean) => void }
>();

// 全局路由监听（只在应用初始化时执行一次）
let globalWatcherInitialized = false;

/**
 * 清空路由参数的函数
 */
export const clearRouteParams = () => {
  globalHashState.value = { moduleId: null, apiId: null };
  // 清空URL中的查询参数
  router.push({
    path: router.currentRoute.value.path,
    query: {},
    replace: true,
  });
};

/**
 * 从路由查询参数中解析状态
 */
const parseQuery = (route: any): HashState => {
  return {
    moduleId: route.query.moduleId ? Number(route.query.moduleId) : null,
    apiId: route.query.apiId ? Number(route.query.apiId) : null,
  };
};

/**
 * 检查模块是否包含目标模块或API
 */
const checkModuleContains = (
  items: any[],
  targetId: number | null
): boolean => {
  if (!items || !Array.isArray(items) || targetId === null) return false;

  return items.some((item) => {
    if (item.id === targetId) return true;
    if (item.children) return checkModuleContains(item.children, targetId);
    return false;
  });
};

/**
 * 检查API是否包含目标API
 */
const checkApiContains = (items: any[], targetId: number | null): boolean => {
  if (!items || !Array.isArray(items) || targetId === null) return false;

  return items.some((item) => {
    if (item.id === targetId) return true;
    if (item.children) return checkApiContains(item.children, targetId);
    return false;
  });
};

/**
 * 模块状态管理 Hook
 */
export function useModuleState(module: Module, route: any) {
  // 使用全局hash状态
  const hashInfo = globalHashState;

  // 展开状态
  const isExpanded = ref(false);

  // 计算属性
  const hasChildren = computed(
    () => module.children && module.children.length > 0
  );
  const hasApis = computed(() => module.apis && module.apis.length > 0);

  // 是否应该展开（包含当前选中的子模块或API）
  const shouldExpand = computed(() => {
    if (!hasChildren.value && !hasApis.value) return false;

    // 如果当前模块被选中（且没有选中API），应该展开
    if (module.id === hashInfo.value.moduleId && !hashInfo.value.apiId) {
      return true;
    }

    // 如果当前模块包含选中的API，应该展开
    if (hashInfo.value.apiId && hasApis.value) {
      return module.apis?.some((api) => api.id === hashInfo.value.apiId);
    }

    // 如果当前模块包含选中的子模块，应该展开
    if (hashInfo.value.moduleId && hasChildren.value) {
      return checkModuleContains(
        module.children || [],
        hashInfo.value.moduleId
      );
    }

    return false;
  });

  // 精确匹配当前模块是否激活（当没有选中API时，模块可以被选中）
  const isActive = computed(
    () => module.id === hashInfo.value.moduleId && !hashInfo.value.apiId
  );

  // 检查API是否激活（API选中时，其所属模块不应该显示为激活状态）
  const isApiActive = (api: any) => api.id === hashInfo.value.apiId;

  // 收起所有子模块
  const collapseAllChildren = () => {
    moduleExpandManagers.forEach((manager, id) => {
      // 检查是否是当前模块的子模块
      const isChild = checkModuleContains(module.children || [], id);
      if (isChild) {
        manager.setExpanded(false);
      }
    });
  };

  // 设置展开状态的函数
  const setExpanded = (expanded: boolean) => {
    isExpanded.value = expanded;
  };

  // 切换展开/折叠状态
  const toggleExpand = () => {
    if (hasChildren.value || hasApis.value) {
      const newExpandedState = !isExpanded.value;
      isExpanded.value = newExpandedState;

      // 如果是要收起，则收起所有子模块
      if (!newExpandedState) {
        collapseAllChildren();
      }
    }
  };

  // 处理模块点击
  const handleModuleClick = () => {
    // 如果模块已经展开，点击就收起
    if (isExpanded.value) {
      toggleExpand();
    } else {
      // 如果模块收起，点击就展开并选中
      toggleExpand();

      // 清除API选中状态，只选中模块
      router.push({
        query: {
          ...route.query,
          moduleId: module.id,
          apiId: undefined, // 清除API选中状态
        },
      });
    }
  };

  // 处理API点击
  const handleApiClick = (api: any) => {
    // 选中API时，同时选中其所属模块，清除其他API选中状态
    router.push({
      query: {
        ...route.query,
        moduleId: module.id,
        apiId: api.id,
      },
    });
  };

  // 创建状态更新函数
  const updateModuleState = () => {
    // 根据新的hash值更新展开状态
    if (shouldExpand.value) {
      isExpanded.value = true;
    }
    // 其他情况保持用户手动展开/折叠的状态
  };

  // 注册到全局更新器
  moduleStateUpdaters.add(updateModuleState);

  // 注册模块展开状态管理器
  moduleExpandManagers.set(module.id, { setExpanded });

  // 初始化时执行一次
  updateModuleState();

  return {
    isActive,
    isExpanded,
    hasChildren,
    hasApis,
    isApiActive,
    toggleExpand,
    handleModuleClick,
    handleApiClick,
    // 返回清理函数，供组件卸载时使用
    cleanup: () => {
      moduleStateUpdaters.delete(updateModuleState);
      moduleExpandManagers.delete(module.id);
    },
  };
}
